/*
 * @Author: AuroCaffe 18509564594@163.com
 * @Date: 2025-01-06 18:51:49
 * @LastEditors: AuroCaffe 18509564594@163.com
 * @LastEditTime: 2025-01-06 18:51:49
 * @FilePath: \HuiLin\minixs\lifecycleMixin.js
 * @Description: 页面生命周期优化混入 - 防止内存泄漏和卡死
 */

import pageActivityManager from '@/utils/pageActivityManager.js';

const lifecycleMixin = {
    data() {
        return {
            // 页面唯一ID
            pageId: null,
            // 页面是否活跃
            isPageActive: true,
            // 定时器列表
            pageTimers: new Set(),
            // 事件监听器列表
            pageEventListeners: new Set(),
            // 页面数据缓存
            pageCache: new Map(),
            // 生命周期管理状态
            lifecycleManaged: true
        }
    },

    // 页面创建时
    onLoad(options) {
        if (this.$options.name && this.$options.name.startsWith('page_')) {
            this.pageId = this.$options.name;
            // 页面创建逻辑
        }
    },

    // 页面挂载时
    onReady() {
        if (this.$options.name && this.$options.name.startsWith('page_')) {
            // 页面挂载逻辑
        }
    },

    // 页面显示时
    onShow() {
        if (this.$options.name && this.$options.name.startsWith('page_')) {
            this.isPageActive = true;
            // 页面显示逻辑
        }
    },

    // 页面隐藏时
    onHide() {
        if (this.$options.name && this.$options.name.startsWith('page_')) {
            this.isPageActive = false;
            // 页面隐藏逻辑
        }
    },

    // 页面卸载时
    onUnload() {
        if (this.$options.name && this.$options.name.startsWith('page_')) {
            this.isPageActive = false;
            this.cleanupPage();
        }
    },

    // 页面卸载时清理资源
    cleanupPage() {
        // 清理所有定时器
        this.clearAllTimers();
        
        // 清理所有事件监听器
        this.removeAllEventListeners();
        
        // 清理页面缓存
        this.clearPageCache();
    },

    // 创建定时器
    createTimer(callback, interval, description = '') {
        if (!this.isPageActive) {
            console.warn(`[LifecycleMixin] 页面非活跃，不创建定时器: ${description}`);
            return null;
        }

        const timerId = setInterval(() => {
            if (this.isPageActive) {
                try {
                    callback();
                } catch (error) {
                    console.error(`[LifecycleMixin] 定时器执行错误: ${description}`, error);
                }
            }
        }, interval);

        this.timers.set(timerId, {
            callback,
            interval,
            description,
            createdAt: Date.now()
        });

        return timerId;
    },

    // 清除定时器
    clearTimer(timerId) {
        if (this.timers.has(timerId)) {
            clearInterval(timerId);
            this.timers.delete(timerId);
        }
    },

    // 清除所有定时器
    clearAllTimers() {
        this.timers.forEach((timer, timerId) => {
            clearInterval(timerId);
        });
        this.timers.clear();
    },

    // 添加事件监听器
    addEventListener(eventName, handler, options = {}) {
        if (!this.isPageActive) {
            console.warn(`[LifecycleMixin] 页面非活跃，不添加事件监听器: ${eventName}`);
            return;
        }

        const wrappedHandler = (...args) => {
            if (this.isPageActive) {
                handler.apply(this, args);
            }
        };

        this.eventListeners.set(eventName, {
            handler: wrappedHandler,
            options,
            addedAt: Date.now()
        });

        // 添加实际的事件监听器
        if (typeof window !== 'undefined') {
            window.addEventListener(eventName, wrappedHandler, options);
        }
    },

    // 移除事件监听器
    removeEventListener(eventName) {
        const listener = this.eventListeners.get(eventName);
        if (listener) {
            if (typeof window !== 'undefined') {
                window.removeEventListener(eventName, listener.handler, listener.options);
            }
            this.eventListeners.delete(eventName);
        }
    },

    // 移除所有事件监听器
    removeAllEventListeners() {
        this.eventListeners.forEach((listener, eventName) => {
            if (typeof window !== 'undefined') {
                window.removeEventListener(eventName, listener.handler, listener.options);
            }
        });
        this.eventListeners.clear();
    },

    // 清理页面缓存
    clearPageCache() {
        // 清理页面相关的缓存数据
        if (this.pageCache) {
            this.pageCache.clear();
        }
    },

    methods: {
        /**
         * 创建页面定时器
         * @param {string} timerId 定时器ID
         * @param {Function} callback 回调函数
         * @param {number} interval 间隔时间
         * @param {string} description 描述
         */
        createPageTimer(timerId, callback, interval = 5000, description = '') {
            if (!this.isPageActive) {
                console.warn(`[LifecycleMixin] 页面非活跃，不创建定时器: ${timerId}`);
                return null;
            }

            // 先清除已存在的定时器
            this.clearPageTimer(timerId);

            const timer = setInterval(() => {
                if (this.isPageActive && callback) {
                    try {
                        callback();
                    } catch (error) {
                        console.error(`[LifecycleMixin] 定时器执行错误: ${timerId}`, error);
                    }
                } else {
                    // 页面不活跃，清除定时器
                    this.clearPageTimer(timerId);
                }
            }, interval);

            // 记录定时器
            this.pageTimers.add(timerId);
            
            // 注册到页面活跃状态管理器
            pageActivityManager.createPageTimer(this.pageId, timerId, callback, interval, description);

            console.log(`[LifecycleMixin] 创建定时器: ${timerId} (${interval}ms)`);
            return timer;
        },

        /**
         * 清除页面定时器
         * @param {string} timerId 定时器ID
         */
        clearPageTimer(timerId) {
            pageActivityManager.clearPageTimer(this.pageId, timerId);
            this.pageTimers.delete(timerId);
            console.log(`[LifecycleMixin] 清除定时器: ${timerId}`);
        },

        /**
         * 清除所有页面定时器
         */
        clearAllTimers() {
            pageActivityManager.clearPageTimers(this.pageId);
            this.pageTimers.clear();
            console.log(`[LifecycleMixin] 清除所有定时器`);
        },

        /**
         * 清除页面定时器（保留页面注册）
         */
        clearPageTimers() {
            pageActivityManager.clearPageTimers(this.pageId);
            this.pageTimers.clear();
        },

        /**
         * 添加事件监听器
         * @param {string} eventName 事件名
         * @param {Function} handler 处理函数
         * @param {Object} target 目标对象
         */
        addEventListener(eventName, handler, target = uni) {
            if (!this.isPageActive) {
                console.warn(`[LifecycleMixin] 页面非活跃，不添加事件监听器: ${eventName}`);
                return;
            }

            const listenerId = `${eventName}_${Date.now()}`;
            this.pageEventListeners.add(listenerId);
            
            // 绑定事件
            if (target.$on) {
                target.$on(eventName, handler);
            } else if (target.addEventListener) {
                target.addEventListener(eventName, handler);
            }

            console.log(`[LifecycleMixin] 添加事件监听器: ${eventName}`);
        },

        /**
         * 移除事件监听器
         * @param {string} eventName 事件名
         * @param {Function} handler 处理函数
         * @param {Object} target 目标对象
         */
        removeEventListener(eventName, handler, target = uni) {
            const listenerId = `${eventName}_${Date.now()}`;
            this.pageEventListeners.delete(listenerId);

            // 解绑事件
            if (target.$off) {
                target.$off(eventName, handler);
            } else if (target.removeEventListener) {
                target.removeEventListener(eventName, handler);
            }

            console.log(`[LifecycleMixin] 移除事件监听器: ${eventName}`);
        },

        /**
         * 移除所有事件监听器
         */
        removeAllEventListeners() {
            this.pageEventListeners.clear();
            console.log(`[LifecycleMixin] 移除所有事件监听器`);
        },

        /**
         * 设置页面缓存
         * @param {string} key 缓存键
         * @param {any} value 缓存值
         * @param {number} expireTime 过期时间（毫秒）
         */
        setPageCache(key, value, expireTime = 5 * 60 * 1000) { // 默认5分钟
            this.pageCache.set(key, {
                value: value,
                expireTime: Date.now() + expireTime
            });
        },

        /**
         * 获取页面缓存
         * @param {string} key 缓存键
         * @returns {any} 缓存值
         */
        getPageCache(key) {
            const cache = this.pageCache.get(key);
            if (cache && Date.now() < cache.expireTime) {
                return cache.value;
            }
            // 清理过期缓存
            this.pageCache.delete(key);
            return null;
        },

        /**
         * 清理页面缓存
         */
        clearPageCache() {
            this.pageCache.clear();
            console.log(`[LifecycleMixin] 清理页面缓存`);
        },

        /**
         * 检查页面是否活跃
         * @returns {boolean}
         */
        checkPageActive() {
            return this.isPageActive;
        },

        /**
         * 获取页面状态信息
         * @returns {Object}
         */
        getPageStatus() {
            return {
                pageId: this.pageId,
                isActive: this.isPageActive,
                timerCount: this.pageTimers.size,
                eventListenerCount: this.pageEventListeners.size,
                cacheCount: this.pageCache.size
            };
        }
    }
};

export default lifecycleMixin;
